package com.itcam.tingshu.album.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.itcam.tingshu.album.mapper.*;
import com.itcam.tingshu.album.service.BaseCategoryService;
import com.itcam.tingshu.model.album.*;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import jakarta.annotation.Resource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Service
@SuppressWarnings({"unchecked", "rawtypes"})
public class BaseCategoryServiceImpl extends ServiceImpl<BaseCategory1Mapper, BaseCategory1> implements BaseCategoryService {

    @Autowired
    private BaseCategory1Mapper baseCategory1Mapper;

    @Autowired
    private BaseCategory2Mapper baseCategory2Mapper;

    @Autowired
    private BaseCategory3Mapper baseCategory3Mapper;

    @Autowired
    private BaseCategoryViewMapper baseCategoryViewMapper;

    @Autowired
    private BaseAttributeMapper baseAttributeMapper;


    /**
     * 查询所有分集数据
     * @return
     */
    @Override
    public List<JSONObject> getBaseCategoryList() {
        // 创建集合
        List<JSONObject> list = new ArrayList<>();
        // 数据封装
        // queryWrapper条件：【查询、更新、删除等条件】 select*from base_category_view;
        // 当null作为参数传递给数据库查询方法时，意味着查询所有符合条件的记录，而不指定额外的过滤条件
        List<BaseCategoryView> baseCategoryViews = baseCategoryViewMapper.selectList(null);
        // 获取一级分类数据 - 按照一级分类Id进行分组获得一个map集合
        // key = category1Id value = List<BaseCategoryView>
        // select category1_id from base_category_view group by category1_id;
        // BaseCategoryView::getCategory1Id 方法引用获取一级分类Id 分组条件：group by category1_id
        // 函数接口都可以使用lambda表达式！复制小括号，写死右箭头，落地大括号！
        Map<Long, List<BaseCategoryView>> map1 = baseCategoryViews.stream().collect(Collectors.groupingBy(BaseCategoryView::getCategory1Id));
        // 循环遍历map集合
        Iterator<Map.Entry<Long, List<BaseCategoryView>>> iterator1 = map1.entrySet().iterator();
        // 遍历判断是否有下一个数据
        while (iterator1.hasNext()) {
            // 从迭代器中获取数据
            Map.Entry<Long, List<BaseCategoryView>> entry1 = iterator1.next();
            // 获取key数据
            Long category1Id = entry1.getKey();
            // 获取value数据
            List<BaseCategoryView> baseCategory1IdViewList = entry1.getValue();
            // 创建一级分类对象
            JSONObject category1 = new JSONObject();
            category1.put("categoryId", category1Id);
            category1.put("categoryName", baseCategory1IdViewList.get(0).getCategory1Name());
            // 声明一个集合来获取二级分类的数据
            List<JSONObject> category2Child = new ArrayList<>();
            // 获取二级分类集合 key=category2Id value =List<BaseCategoryView>
            Map<Long, List<BaseCategoryView>> map2 = baseCategory1IdViewList.stream().collect(Collectors.groupingBy(BaseCategoryView::getCategory2Id));
            // 循环遍历map2集合
            Iterator<Map.Entry<Long, List<BaseCategoryView>>> iterator2 = map2.entrySet().iterator();
            // 遍历判断是否有下一个数据
            while (iterator2.hasNext()) {
                // 从迭代器中获取数据
                Map.Entry<Long, List<BaseCategoryView>> entry2 = iterator2.next();
                // 创建二级分类对象
                JSONObject category2 = new JSONObject();
                Long category2Id = entry2.getKey();
                List<BaseCategoryView> baseCategory2IdViewList = entry2.getValue();
                category2.put("categoryId", category2Id);
                category2.put("categoryName", baseCategory2IdViewList.get(0).getCategory2Name());
                // 声明一个集合来获取三级分类数据
                List<JSONObject> category3Child = new ArrayList<>();
                // 获取三级分类集合，并添加到二级分类中
                baseCategory2IdViewList.stream().forEach(baseCategoryView -> {
                    // 创建三级分类对象
                    JSONObject category3 = new JSONObject();
                    category3.put("categoryId", baseCategoryView.getCategory3Id());
                    category3.put("categoryName", baseCategoryView.getCategory3Name());
                    // 将三级分类对象添加到集合中
                    category3Child.add(category3);
                });
                // 将三级分类集合添加到二级分类集合
                category2.put("categoryChild", category3Child);
                // 将二级分类对象添加到集合中
                category2Child.add(category2);
            }
            // 将二级分类集合添加到一级分类集合
            category1.put("categoryChild", category2Child);
            // 将一级分类集合添加到最外层集合
            list.add(category1);
        }
        return list;
    }

    /**
     * 根据一级分类Id获取属性标签数据
     * @param category1Id
     * @return
     */
    @Override
    public List<BaseAttribute> findAttribute(Long category1Id) {
        //  根据一级分类Id获取属性标签数据 sql
        return baseAttributeMapper.selectAttribute(category1Id);
    }

    /**
     * 根据三级分类Id获取分类数据——根据分类ID获取分类视图
     * 此方法通过ID从数据库中检索特定的分类视图对象。它被设计为覆盖父类方法，提供了一个专门针对分类ID获取分类视图的实现。
     * @param category3Id   分类的第三层ID，用于唯一标识一个分类。
     * @return 返回匹配的BaseCategoryView对象，如果找不到，则返回null。
     */
    @Override
    public BaseCategoryView getCategoryView(Long category3Id) {
        return baseCategoryViewMapper.selectById(category3Id);
    }

    /**
     * 根据一级分类Id获取分类数据
     * @param category1Id
     * @return
     */
    @Override
    public JSONObject getBaseCategoryList(Long category1Id) {
        // 创建JSONObject对象
        JSONObject category1 = new JSONObject();
        // 根据一级分类Id查找一级分类名
        // select name from base_category1 where id = 1;
        // select * from base_category_view where category1_id = ?;
        List<BaseCategoryView> baseCategoryViewList = baseCategoryViewMapper.selectList(new LambdaQueryWrapper<BaseCategoryView>()
                .eq(BaseCategoryView::getCategory1Id, category1Id));
        // 封装一级分类数据
        category1.put("categoryId", category1Id);
        category1.put("categoryName", baseCategoryViewList.get(0).getCategory1Name());
        // 查询二级分类数据 —— 根据分类Id分组读取数据
        Map<Long, List<BaseCategoryView>> map = baseCategoryViewList.stream().collect(Collectors.groupingBy(BaseCategoryView::getCategory2Id));
        // 循环遍历map集合
        Iterator<Map.Entry<Long, List<BaseCategoryView>>> iterator = map.entrySet().iterator();
        ArrayList<JSONObject> category2ChildList = new ArrayList<>();
        while (iterator.hasNext()) {
            // 创建二级分类对象
            JSONObject category2 = new JSONObject();
            // 获取数据
            Map.Entry<Long, List<BaseCategoryView>> entry = iterator.next();
            Long category2Id = entry.getKey();
            category2.put("categoryId", category2Id);
            category2.put("categoryName", entry.getValue().get(0).getCategory2Name());

            // 获取三级分类数据
            List<JSONObject> category3ChildList = entry.getValue().stream()
                    .map(BaseCategoryView -> {
                        // 声明对象
                        JSONObject category3 = new JSONObject();
                        // 赋值
                        category3.put("categoryId", BaseCategoryView.getCategory3Id());
                        category3.put("categoryName", BaseCategoryView.getCategory3Name());
                        return category3;
                    }).collect(Collectors.toList());
            // 添加三级分类数据
            category2.put("categoryChild", category3ChildList);
            category2ChildList.add(category2);
        }
        // 将二级分类数据保存到一级分类中
        category1.put("categoryChild", category2ChildList);
        // 返回数据
        return category1;
    }

    /**
     * 根据一级分类Id查询置顶到频道页的三级分类列表
     * @param category1Id
     * @return
     */
    @Override
    public List<BaseCategory3> findTopBaseCategory3(Long category1Id) {
        // 先找到二级分类对象
        List<BaseCategory2> baseCategory2List = this.baseCategory2Mapper.selectList(new LambdaQueryWrapper<BaseCategory2>()
                .eq(BaseCategory2::getCategory1Id, category1Id));
        // 找到二级分类Id集合，BaseCategory2::getId获取二级分类Id
        List<Long> category2IdList = baseCategory2List.stream().map(BaseCategory2::getId).collect(Collectors.toList());

        /*
            根据一级分类Id查询三级分类数据
            select * from base_category3 c3 left join base_category2 c2 on c3.category2_id = c2.id
                where c2.category1_id = 2 and c3.is_top = 1 limit 7;
         */
        LambdaQueryWrapper<BaseCategory3> queryWrapper = new LambdaQueryWrapper<BaseCategory3>()
                .in(BaseCategory3::getCategory2Id, category2IdList)
                .eq(BaseCategory3::getIsTop, 1)
                .last(" limit 7 ");

        return baseCategory3Mapper.selectList(queryWrapper);
    }

    /**
     * 获取一级分类列表
     * @return
     */
    @Override
    public List<BaseCategory1> findAllCategory1() {
        //  查询所有数据
        return baseCategory1Mapper.selectList(null);
    }
}









